/**
 * 激励视频广告管理器（完整版 - 支持重试、降级和调试）
 */
class RewardVideoAdManager {
  constructor() {
    this._rewardedVideoAd = null;
    this._isLoadedAd = false;
    this._isApp = null;  // ✅ 改为 null，表示未检测
    this._isLoading = false;
    this._retryCount = 0;
    this._maxRetries = 3;
    this._isUserTriggered = false;  // ✅ 是否为用户主动触发
    this._isShowingDialog = false;  // ✅ 是否正在显示弹窗
    this._userId = null;  // ✅ 当前 userId
    this._isUpdatingUserId = false;  // ✅ 是否正在更新 userId

    // ✅ 静默重试配置
    this._silentRetryCount = 0;  // 静默重试次数
    this._maxSilentRetries = 2;  // 最大静默重试次数（页面初始化时）
    this._silentRetryTimer = null;  // 静默重试定时器

    // ✅ 调试开关（直接在这里修改）
    this._debugMode = false;  // 改为 true 开启调试
    this._debugErrorType = 'normal';  // 'retry' | 'system' | 'normal'

    // 回调函数
    this.onAdComplete = null;
    this.onAdIncomplete = null;
    this.onH5Fallback = null;
    this.onFallback = null;

    console.log('广告管理器初始化完成');
    if (this._debugMode) {
      console.log(`🐛 调试模式已开启，错误类型: ${this._debugErrorType}`);
    }
  }

  /**
   * 检测运行环境
   */
  checkEnvironment() {
    try {
      const systemInfo = uni.getSystemInfoSync();
      const platform = systemInfo.platform;

      console.log('platform', platform);
      console.log('window:', typeof window !== 'undefined');
      console.log('uni.createRewardedVideoAd:', typeof uni.createRewardedVideoAd);

      // ✅ 多种方式检测是否为 App 环境
      this._isApp = platform === 'android' || platform === 'ios';

      // ✅ 额外检查：如果 API 不存在，则不是 App 环境
      if (typeof uni.createRewardedVideoAd !== 'function') {
        console.warn('createRewardedVideoAd API 不存在，判断为 H5 环境');
        this._isApp = false;
      }

      console.log('运行环境:', this._isApp ? 'App' : 'H5');
      return this._isApp;
    } catch (err) {
      console.error('环境检测失败:', err);
      this._isApp = false;
      return false;
    }
  }

  /**
   * 初始化激励视频广告
   */
  init(options = {}) {
    // ✅ 如果已经初始化过且有实例，不需要重新初始化
    if (this._rewardedVideoAd) {
      console.log('广告已经初始化，跳过重复初始化');
      return;
    }

    // ✅ 保存 userId（如果有传入）
    const { userId } = options;
    if (userId) {
      this._userId = userId;
    }

    // ✅ 标记为非用户触发（初始化时的自动加载）
    this._isUserTriggered = false;

    // ✅ 检查环境（只在第一次初始化时检测）
    if (this._isApp === undefined || this._isApp === null) {
      this.checkEnvironment();
    }

    if (!this._isApp) {
      console.log('H5环境不支持激励视频广告');
      this._rewardedVideoAd = null;
      return;
    }

    // ✅ 检查 API 是否存在
    if (typeof uni.createRewardedVideoAd !== 'function') {
      console.warn('当前环境不支持 createRewardedVideoAd API');
      this._isApp = false;
      this._rewardedVideoAd = null;
      return;
    }

    this._isLoadedAd = false;
    this._retryCount = 0;

    console.log('=== 创建激励视频广告 ===');
    console.log('广告位ID: 1748458063');

    try {
      this._rewardedVideoAd = uni.createRewardedVideoAd({
        adpid: '1748458063'
      });

      this._bindEvents();

      // ✅ 自动加载广告
      if (!this._isLoadedAd) {
        console.log('开始自动加载广告...');
        this._rewardedVideoAd.load().then(() => {
          console.log('广告自动加载成功');
        }).catch((err) => {
          console.log('广告自动加载失败（不影响使用）:', err);
        });
      }

      console.log('✅ 激励视频广告初始化完成');
    } catch (err) {
      console.error('创建激励视频广告失败:', err);
      this._rewardedVideoAd = null;
      this._isApp = false;
    }
  }

  /**
   * 绑定广告事件（支持失败后重新拉取、降级和调试）
   */
  _bindEvents() {
    if (!this._rewardedVideoAd) return;
    
    // ✅ 添加实例追踪日志
    const instanceId = Math.random().toString(36).substr(2, 9);
    console.log(`🔗 绑定广告事件，实例ID: ${instanceId}`);
    this._currentInstanceId = instanceId;

    this._rewardedVideoAd.onLoad(() => {
      // ✅ 调试模式：模拟加载失败
      if (this._debugMode) {
        console.log('🐛 调试模式：模拟广告加载失败');
        this._isLoadedAd = false;
        this._isLoading = false;

        // 模拟不同类型的错误
        let mockError = {};

        if (this._debugErrorType === 'system') {
          // 模拟系统错误（直接降级）
          mockError = {
            code: -5001,
            errMsg: '【模擬】廣告服務異常'
          };
          console.log('🐛 模拟系统错误:', mockError);
        } else if (this._debugErrorType === 'retry') {
          // 模拟需要重试的错误（重试3次后降级）
          mockError = {
            code: -5005,
            errMsg: '【模擬】廣告加載失敗，請稍後重試'
          };
          console.log('🐛 模拟重试错误:', mockError);
        } else {
          // normal 模式不模拟错误
          this._isLoadedAd = true;
          this._isLoading = false;
          this._retryCount = 0;
          console.log('✅ 激励视频广告加载成功');
          return;
        }

        // 触发模拟错误
        setTimeout(() => {
          this._handleError(mockError);
        }, 500);

        return;
      }

      // 正常逻辑
      this._isLoadedAd = true;
      this._isLoading = false;
      this._retryCount = 0;
      this._silentRetryCount = 0;  // ✅ 重置静默重试计数

      // ✅ 清理静默重试定时器
      if (this._silentRetryTimer) {
        clearTimeout(this._silentRetryTimer);
        this._silentRetryTimer = null;
      }
      console.log('✅ 激励视频广告加载成功');
    });

    this._rewardedVideoAd.onError((err) => {
      this._isLoadedAd = false;
      this._isLoading = false;
      console.error('❌ 激励视频广告加载失败:', err);
    });

    this._rewardedVideoAd.onClose((res) => {
      console.log(`📱 [实例${this._currentInstanceId}] 激励视频广告关闭:`, res);
      console.log(`⚠️ 当前广告实例数量检查...`);
      
      // ✅ 检查是否有其他实例
      if (this._rewardedVideoAd) {
        console.log(`✅ 当前实例存在: ${this._currentInstanceId}`);
      }
      
      this._handleAdClose(res);
    });
  }

  /**
   * 处理错误（统一错误处理逻辑）
   */
  _handleError(err) {
    const errCode = err && err.code ? err.code : '';
    const errMsg = err && err.errMsg ? err.errMsg : '未知错误';

    const debugPrefix = this._debugMode ? '【調試】' : '';
    console.log(`${debugPrefix}错误码: ${errCode}, 错误信息: ${errMsg}, 重试次数: ${this._retryCount}/${this._maxRetries}, 用户触发: ${this._isUserTriggered}`);

    // ✅ 如果不是用户触发的（页面初始化时的自动加载），静默处理
    if (!this._isUserTriggered) {
      console.log(`页面初始化时广告加载失败，静默处理（不提示用户）静默重试: ${this._silentRetryCount}/${this._maxSilentRetries}`);

      // ✅ 静默重试机制
      if (this._silentRetryCount < this._maxSilentRetries) {
        this._silentRetryCount++;
        const retryDelay = 1000 * this._silentRetryCount;  // ✅ 1秒、2秒、3秒递增
        console.log(`📌 将在 ${retryDelay / 1000} 秒后静默重试第 ${this._silentRetryCount} 次`);

        // 清除之前的定时器
        if (this._silentRetryTimer) {
          clearTimeout(this._silentRetryTimer);
        }

        // 延迟后静默重试
        this._silentRetryTimer = setTimeout(() => {
          console.log(`🔄 开始静默重试第 ${this._silentRetryCount} 次...`);
          this._silentRetryAd();
        }, retryDelay);
      } else {
        console.log('❌ 静默重试次数已用完，放弃后台加载（用户点击时会重新加载）');
        this._silentRetryCount = 0;
      }

      // 不弹窗、用户无感知
      return;
    }

    // 判断是否为系统错误
    const isSystemError = this._isSystemError(errCode);

    // 判断是否已达到最大重试次数
    const reachedMaxRetries = this._retryCount >= this._maxRetries;

    if (isSystemError) {
      // ✅ 系统错误，直接降级
      console.log(`${debugPrefix}检测到系统错误，执行降级处理`);
      this._handleFallback(`${debugPrefix}系統錯誤`, '廣告服務異常，請20分鐘後重試');
    } else if (reachedMaxRetries) {
      // ✅ 重试次数用完，降级
      console.log(`${debugPrefix}重试次数已达上限，执行降级处理`);
      this._handleFallback(`${debugPrefix}重試次數已用完`, '廣告服務異常，請20分鐘後重試');
    } else {
      // ✅ 防止重复弹窗
      if (this._isShowingDialog) {
        console.log('已经有弹窗在显示，跳过重复弹窗');
        return;
      }

      // ✅ 还有重试机会，显示当前已完成的重试次数
      const currentRetry = this._retryCount;

      // ✅ 标记正在显示弹窗
      this._isShowingDialog = true;

      // 提供重新加载选项
      const codeText = errCode !== '' ? `\n錯誤碼: ${errCode}` : '';
      uni.showModal({
        title: `${debugPrefix}廣告加載失敗`,
        content: `${errMsg}${codeText}\n\n重試次數: ${currentRetry}/${this._maxRetries}\n\n是否重新加載？`,
        confirmText: '重新加載',
        cancelText: '放棄',
        success: (res) => {
          // ✅ 弹窗关闭，清除标记
          this._isShowingDialog = false;

          if (res.confirm) {
            // ✅ 用户选择重新拉取，增加重试计数
            this._retryCount++;
            console.log(`${debugPrefix}用户选择重新拉取广告 (第${this._retryCount}次重试)`);

            // 调试模式：继续模拟失败
            if (this._debugMode) {
              // ✅ 调试模式也显示 Loading，体验一致
              uni.showLoading({
                title: `【調試】重新加載中 (${this._retryCount}/${this._maxRetries})...`
              });

              setTimeout(() => {
                uni.hideLoading();
                this._handleError(err);
              }, 1000);
            } else {
              // 正常模式：调用重新加载
              // ✅ 注意：_reloadAd 内部也会根据 retryCount 显示进度
              this._reloadAd();
            }
          } else {
            console.log('用户取消重新拉取，结束广告流程');
            // ✅ 用户点击放弃，直接返回，不再继续
            this._retryCount = 0;
            this._isUserTriggered = false;  // ✅ 重置用户触发标志
            // ✅ 不再调用任何方法，直接结束
          }
        }
      });
    }
  }

  /**
   * 判断是否为系统错误（需要降级的错误）
   */
  _isSystemError(errCode) {
    const systemErrors = [
      -5001,  // 广告服务异常
      -5003,  // 广告数据错误
      -5004,  // 广告容器错误
      -1      // 系统错误
    ];
    return systemErrors.includes(Number(errCode));
  }

  /**
   * 执行降级处理（给用户领取果实）
   */
  _handleFallback(title, content) {
    // ✅ 防止重复弹窗
    if (this._isShowingDialog) {
      console.log('已经有弹窗在显示，跳过重复弹窗');
      return;
    }

    this._isShowingDialog = true;

    uni.showModal({
      title: title,
      content: content + '\n\n感謝您的理解',
      confirmText: '確定',
      showCancel: false,
      success: () => {
        // ✅ 弹窗关闭，清除标记
        this._isShowingDialog = false;

        console.log('✅ 执行降级处理，允许用户领取果实');

        // ✅ 调用降级回调，让用户领取果实
        if (this.onFallback) {
          this.onFallback();
        }

        // 重置状态
        this._retryCount = 0;
        this._isUserTriggered = false;  // ✅ 重置用户触发标志
      }
    });
  }

  /**
   * 静默重试广告加载（后台重试，不打扰用户）
   */
  _silentRetryAd() {
    if (!this._rewardedVideoAd) {
      console.log('广告实例不存在，无法静默重试');
      return;
    }

    if (this._isLoading) {
      console.log('广告正在加载中，跳过静默重试');
      return;
    }

    // ✅ 如果已经加载成功，无需重试
    if (this._isLoadedAd) {
      console.log('✅ 广告已加载成功，无需静默重试');
      this._silentRetryCount = 0;  // 重置静默重试计数
      return;
    }

    console.log(`🔄 静默重试第 ${this._silentRetryCount} 次加载广告...`);
    this._isLoading = true;

    this._rewardedVideoAd.load()
      .then(() => {
        this._isLoading = false;
        console.log(`✅ 静默重试第 ${this._silentRetryCount} 次成功，广告已准备就绪`);
        this._silentRetryCount = 0;  // 重置静默重试计数

        // ✅ 清理静默重试定时器
        if (this._silentRetryTimer) {
          clearTimeout(this._silentRetryTimer);
          this._silentRetryTimer = null;
        }
      })
      .catch((err) => {
        this._isLoading = false;
        console.log(`❌ 静默重试第 ${this._silentRetryCount} 次失败:`, err);
        // ✅ 失败后会在 _handleError 中继续静默重试（如果未达上限）
        // 不做额外处理，避免递归
      });
  }

  /**
   * 重新拉取广告（官方推荐方法）
   */
  _reloadAd() {
    if (!this._rewardedVideoAd) {
      console.log('广告实例不存在，无法重新拉取');
      return;
    }

    if (this._isLoading) {
      console.log('广告正在加载中，请稍候');
      return;
    }

    console.log(`开始重新拉取广告... (第${this._retryCount}次重试)`);
    this._isLoading = true;
    this._isLoadedAd = false;

    // ✅ 显示正确的重试次数（当前次数）
    const displayCount = this._retryCount;
    uni.showLoading({
      title: `重新加載中 (${displayCount}/${this._maxRetries})...`
    });

    this._rewardedVideoAd.load()
      .then(() => {
        uni.hideLoading();
        console.log('✅ 重新拉取成功');
        this._retryCount = 0;
        this._silentRetryCount = 0;  // ✅ 重置静默重试计数

        // ✅ 清理静默重试定时器
        if (this._silentRetryTimer) {
          clearTimeout(this._silentRetryTimer);
          this._silentRetryTimer = null;
        }

        uni.showToast({
          title: '加載成功',
          icon: 'success',
          duration: 1500
        });
      })
      .catch((err) => {
        uni.hideLoading();
        this._isLoading = false;
        console.error(`❌ 第${this._retryCount}次重新拉取失败:`, err);

        const errCode = err && err.code ? err.code : '';
        const isSystemError = this._isSystemError(errCode);

        // ✅ 判断下次重试是第几次
        const nextRetryCount = this._retryCount + 1;

        if (isSystemError || nextRetryCount > this._maxRetries) {
          const reason = isSystemError ? '系統錯誤' : '重試次數已用完';
          this._handleFallback(reason, '廣告服務異常，請20分鐘後重試');
        } else {
          // ✅ 防止重复弹窗
          if (this._isShowingDialog) {
            console.log('已经有弹窗在显示，跳过重复弹窗');
            return;
          }

          // ✅ 计算下次重试是第几次（在用户确认后会执行）
          const nextAttempt = this._retryCount + 1;
          const remainingAttempts = this._maxRetries - this._retryCount;
          const isLastAttempt = remainingAttempts <= 1;

          // ✅ 标记正在显示弹窗
          this._isShowingDialog = true;

          const errMsg = err && err.errMsg ? err.errMsg : '廣告加載失敗，請稍後重試';
          const errCodeText = err && err.code ? `\n錯誤碼: ${err.code}` : '';
          uni.showModal({
            title: '重新加載失敗',
            content: `${errMsg}${errCodeText}\n\n第${this._retryCount}次重試失敗\n\n重試次數: ${this._retryCount}/${this._maxRetries}\n\n${isLastAttempt ? '這是最後一次重試機會' : `還可重試 ${remainingAttempts - 1} 次`}\n\n是否再試一次？`,
            confirmText: '再試一次',
            cancelText: '放棄',
            success: (res) => {
              // ✅ 弹窗关闭，清除标记
              this._isShowingDialog = false;

              if (res.confirm) {
                // ✅ 弹窗已自动关闭，增加重试次数并重新加载
                this._retryCount++;
                console.log(`✅ 用户选择第${this._retryCount}次重试 (总共${this._maxRetries}次)`);

                // ✅ 递归调用 _reloadAd，继续重试
                this._reloadAd();  // 会立即显示 Loading
              } else {
                console.log('用户取消重试，结束广告显示流程');
                // ✅ 用户点击放弃，结束整个流程（不再弹窗）
                this._retryCount = 0;
                this._isUserTriggered = false;  // ✅ 重置用户触发标志
                // ✅ 不再继续，流程结束
              }
            }
          });
        }
      });
  }

  /**
   * 显示广告（优化版）
   */
  async showRewardedVideoAd(options = {}) {
    const { userId, resetRetryCount = true } = options;
    
    // ✅ 如果传入了 userId，先更新 userId（确保使用正确的 userId）
    if (userId) {
      // ✅ 首次设置或 userId 变化时，更新广告实例
      if (!this._userId || this._userId === 'testuser' || this._userId !== userId) {
        console.log(`准备更新 userId: ${this._userId} -> ${userId}`);
        await this.updateUserId(userId);
      } else {
        console.log(`userId 未变化: ${userId}，使用现有实例`);
      }
    }
    
    // ✅ 标记为用户主动触发
    this._isUserTriggered = true;

    // ✅ 清除静默重试定时器和计数（用户主动触发时）
    if (this._silentRetryTimer) {
      clearTimeout(this._silentRetryTimer);
      this._silentRetryTimer = null;
    }
    this._silentRetryCount = 0;

    // ✅ 根据参数决定是否重置重试计数
    // resetRetryCount = true: 从页面发起的全新请求
    // resetRetryCount = false: 内部递归调用（保持计数）
    if (resetRetryCount) {
      console.log('全新请求，重置重试计数');
      this._retryCount = 0;
    }

    if (!this._isApp) {
      this._handleH5Fallback();
      return false;
    }

    if (!this._rewardedVideoAd) {
      console.log('广告未初始化，正在自动初始化...');

      // ✅ 先检查环境，确保环境检测正确
      if (this._isApp === undefined || this._isApp === null) {
        this.checkEnvironment();
      }

      // ✅ 如果不是App环境，直接返回H5降级
      if (!this._isApp) {
        console.log('当前不是App环境，无法显示广告');
        this._handleH5Fallback();
        return false;
      }

      // ✅ 初始化广告
      this.init();

      // ✅ 如果初始化后还是没有广告实例，说明环境不支持
      if (!this._rewardedVideoAd) {
        console.error('广告初始化失败，当前环境不支持');
        this._handleH5Fallback();
        return false;
      }

      // ✅ 等待一下让广告实例完全创建
      await new Promise(resolve => setTimeout(resolve, 300));
    }

    if (!this._isLoadedAd) {
      console.log('广告未加载，尝试手动加载...');

      // ✅ 再次检查广告实例
      if (!this._rewardedVideoAd) {
        console.error('广告实例不存在');
        this._handleH5Fallback();
        return false;
      }

      uni.showLoading({
        title: '廣告準備中...'
      });

      try {
        this._retryCount++;
        await this._rewardedVideoAd.load();
        await this._waitForAdLoad(3000);

        uni.hideLoading();
        this._retryCount = 0;
        this._silentRetryCount = 0;  // ✅ 重置静默重试计数

        // ✅ 清理静默重试定时器
        if (this._silentRetryTimer) {
          clearTimeout(this._silentRetryTimer);
          this._silentRetryTimer = null;
        }

        console.log('广告加载成功，准备显示');
      } catch (err) {
        uni.hideLoading();
        console.error('广告加载失败:', err);

        if (this._retryCount >= this._maxRetries) {
          this._handleFallback('重試次數已用完', '廣告服務異常，請20分鐘後重試');
          return false;
        }

        const retry = await this._showLoadFailDialog(err);
        if (retry) {
          // ✅ 递归调用时不重置重试计数，保留 userId
          return await this.showRewardedVideoAd({ resetRetryCount: false });
        }

        // ✅ 用户放弃重试的逻辑已经在 _showLoadFailDialog 中处理了
        return false;
      }
    }

    try {
      await this._rewardedVideoAd.show();
      return true;
    } catch (err) {
      console.error('显示广告失败:', err);

      const errCode = err && err.code ? err.code : '';
      const errMsg = err && err.errMsg ? err.errMsg : '未知错误';

      if (this._isSystemError(errCode)) {
        this._handleFallback('系統錯誤', '廣告服務異常，請20分鐘後重試');
        return false;
      }

      // ✅ 防止重复弹窗
      if (!this._isShowingDialog) {
        this._isShowingDialog = true;

        const codeText = errCode !== '' ? `\n\n錯誤碼: ${errCode}` : '';
        uni.showModal({
          title: '廣告顯示失敗',
          content: `${errMsg}${codeText}`,
          confirmText: '重試',
          cancelText: '放棄',
          success: async (res) => {
            // ✅ 弹窗关闭，清除标记
            this._isShowingDialog = false;

            if (res.confirm) {
              // ✅ 弹窗已自动关闭
              this._retryCount++;
              if (this._retryCount >= this._maxRetries) {
                this._handleFallback('重試次數已用完', '廣告服務異常，請20分鐘後重試');
              } else {
                this._reloadAd();  // 会立即显示 Loading
              }
            } else {
              console.log('用户放弃观看广告，重置重试计数');
              // ✅ 用户点击放弃，重置重试计数
              this._retryCount = 0;
              this._isUserTriggered = false;  // ✅ 重置用户触发标志
            }
          }
        });
      }

      return false;
    }
  }

  /**
   * 显示加载失败对话框
   */
  _showLoadFailDialog(err) {
    return new Promise((resolve) => {
      // ✅ 防止重复弹窗
      if (this._isShowingDialog) {
        console.log('已经有弹窗在显示，直接返回 false');
        resolve(false);
        return;
      }

      this._isShowingDialog = true;

      const errCode = err && (err.code || err.errCode) ? (err.code || err.errCode) : '';
      const errMsg = err && err.errMsg ? err.errMsg : (err && err.message ? err.message : '廣告還未準備好');
      const codeText = errCode !== '' ? `\n錯誤碼: ${errCode}` : '';

      uni.showModal({
        title: '廣告加載失敗',
        content: `${errMsg}${codeText}\n\n重試次數: ${this._retryCount}/${this._maxRetries}\n\n是否重試？`,
        confirmText: '重試',
        cancelText: '放棄',
        success: (res) => {
          // ✅ 弹窗关闭，清除标记
          this._isShowingDialog = false;

          if (res.confirm) {
            // ✅ 用户选择重试
            resolve(true);
          } else {
            // ✅ 用户选择放弃，重置重试计数
            console.log('用户放弃重试广告加载，重置重试计数');
            this._retryCount = 0;
            this._isUserTriggered = false;
            resolve(false);
          }
        }
      });
    });
  }

  /**
   * 等待广告加载完成
   */
  _waitForAdLoad(timeout = 3000) {
    return new Promise((resolve, reject) => {
      const timer = setTimeout(() => {
        reject(new Error('广告加载超时'));
      }, timeout);

      const checkLoad = () => {
        if (this._isLoadedAd) {
          clearTimeout(timer);
          resolve();
        } else {
          setTimeout(checkLoad, 100);
        }
      };

      checkLoad();
    });
  }

  /**
   * 处理广告关闭
   */
  _handleAdClose(res) {
    console.log(`⚠️ _handleAdClose 被调用，当前实例ID: ${this._currentInstanceId}`);
    
    if (res && res.isEnded) {
      console.log('✅ 用户观看完整广告');
      // uni.showToast({
      //   title: '觀看完成，獎勵領取中！',
      //   icon: 'success'
      // });
      this._retryCount = 0;
      this._isUserTriggered = false;  // ✅ 重置用户触发标志

      if (this.onAdComplete) {
        console.log(`⚠️ 调用 onAdComplete 回调`);
        this.onAdComplete(res);
        console.log(`⚠️ onAdComplete 回调已调用`);
      } else {
        console.warn('⚠️ onAdComplete 回调未设置！');
      }

      // ✅ 不预加载下一个广告（领取间隔6小时，无需预加载）
      // 如果需要预加载，取消注释下面的代码：
      // setTimeout(() => {
      //   this._preloadNextAd();
      // }, 1000);

      console.log('广告观看完成，下次领取需间隔6小时');
    } else {
      console.log('❌ 用户未观看完整');
      this._retryCount = 0;
      this._isUserTriggered = false;  // ✅ 重置用户触发标志

      uni.showToast({
        title: '需要觀看完整廣告才能獲得獎勵',
        icon: 'none'
      });

      if (this.onAdIncomplete) {
        this.onAdIncomplete(res);
      }
    }
  }

  /**
   * 预加载下一个广告（已禁用 - 领取间隔6小时，无需预加载）
   * 如果未来需要预加载，可以启用此方法
   */
  _preloadNextAd() {
    if (!this._rewardedVideoAd) return;

    // ✅ 延迟5秒，给广告平台准备新广告的时间
    setTimeout(() => {
      console.log('开始预加载下一个广告...');
      this._isLoadedAd = false;

      this._rewardedVideoAd.load()
        .then(() => {
          console.log('✅ 预加载成功，下一次可直接显示广告');
          this._silentRetryCount = 0;  // ✅ 重置静默重试计数

          // ✅ 清理静默重试定时器
          if (this._silentRetryTimer) {
            clearTimeout(this._silentRetryTimer);
            this._silentRetryTimer = null;
          }
        })
        .catch((err) => {
          const errCode = err && err.code ? err.code : '';
          const errMsg = err && err.errMsg ? err.errMsg : '';

          console.log('预加载失败（不影响使用）:', {
            code: errCode,
            message: errMsg
          });

          // ✅ 预加载失败不影响用户，下次点击时会自动加载
          // 根据错误码决定是否静默重试
          if (errCode === -5005) {
            // 无广告填充或网络问题，15秒后静默重试一次
            console.log('15秒后静默重试预加载...');
            setTimeout(() => {
              if (this._rewardedVideoAd && !this._isLoadedAd) {
                this._rewardedVideoAd.load()
                  .then(() => {
                    console.log('✅ 预加载重试成功');
                    this._silentRetryCount = 0;  // ✅ 重置静默重试计数

                    // ✅ 清理静默重试定时器
                    if (this._silentRetryTimer) {
                      clearTimeout(this._silentRetryTimer);
                      this._silentRetryTimer = null;
                    }
                  })
                  .catch(() => console.log('预加载重试失败（用户下次点击时自动加载）'));
              }
            }, 15000);
          } else {
            // 其他错误，不重试，用户下次点击时自动加载
            console.log('用户下次点击领取时会自动加载广告');
          }
        });
    }, 5000);  // 延迟5秒
  }

  /**
   * H5环境降级处理
   */
  _handleH5Fallback() {
    // ✅ 防止重复弹窗
    if (this._isShowingDialog) {
      console.log('已经有弹窗在显示，跳过H5弹窗');
      return;
    }

    this._isShowingDialog = true;

    uni.showModal({
      title: '提示',
      content: '此功能需要在App中使用，請下載App體驗完整功能',
      confirmText: '下載App',
      cancelText: '取消',
      success: (res) => {
        // ✅ 弹窗关闭，清除标记
        this._isShowingDialog = false;

        if (res.confirm) {
          if (this.onH5Fallback) {
            this.onH5Fallback();
          }
        }
      }
    });
  }

  /**
   * 显示确认弹窗
   */
  showConfirm(content) {
    return new Promise((resolve) => {
      // ✅ 防止重复弹窗
      if (this._isShowingDialog) {
        console.log('已经有弹窗在显示，跳过确认弹窗');
        resolve(false);
        return;
      }

      this._isShowingDialog = true;

      uni.showModal({
        title: '提示',
        content: content,
        confirmText: '觀看廣告',
        cancelText: '取消',
        success: (res) => {
          // ✅ 弹窗关闭，清除标记
          this._isShowingDialog = false;

          resolve(res.confirm);
        }
      });
    });
  }

  /**
   * 预加载广告（对外暴露 - 供页面调用）
   * 建议在页面 onShow 时调用，确保6小时后能快速显示广告
   */
  preload() {
    // ✅ 标记为非用户触发（静默加载）
    this._isUserTriggered = false;

    if (!this._isApp) {
      console.log('H5环境不支持预加载');
      return;
    }

    if (!this._rewardedVideoAd) {
      console.log('广告未初始化，无法预加载');
      return;
    }

    // 如果已经加载成功，无需重复加载
    if (this._isLoadedAd) {
      console.log('广告已加载，无需预加载');
      return;
    }

    // 如果正在加载中，避免重复加载
    if (this._isLoading) {
      console.log('广告正在加载中，请稍候');
      return;
    }

    console.log('开始预加载广告（静默模式）...');
    this._isLoading = true;
    this._isLoadedAd = false;

    this._rewardedVideoAd.load()
      .then(() => {
        this._isLoading = false;
        console.log('✅ 预加载成功');
        this._silentRetryCount = 0;  // ✅ 重置静默重试计数

        // ✅ 清理静默重试定时器
        if (this._silentRetryTimer) {
          clearTimeout(this._silentRetryTimer);
          this._silentRetryTimer = null;
        }
      })
      .catch((err) => {
        this._isLoading = false;
        console.log('预加载失败（静默处理，用户点击时会自动加载）:', err);
        // ✅ 静默失败，不弹窗、不提示
      });
  }

  /**
   * 设置回调函数
   */
  setCallbacks(callbacks = {}) {
    this.onAdComplete = callbacks.onAdComplete;
    this.onAdIncomplete = callbacks.onAdIncomplete;
    this.onH5Fallback = callbacks.onH5Fallback;
    this.onFallback = callbacks.onFallback;

    console.log('回调函数设置完成:', Object.keys(callbacks));
  }

  /**
   * 获取广告状态
   */
  getStatus() {
    return {
      isApp: this._isApp,
      isLoaded: this._isLoadedAd,
      isLoading: this._isLoading,
      hasAd: !!this._rewardedVideoAd,
      retryCount: this._retryCount,
      maxRetries: this._maxRetries,
      silentRetryCount: this._silentRetryCount,
      maxSilentRetries: this._maxSilentRetries,
      debugMode: this._debugMode,
      debugErrorType: this._debugErrorType,
      isUserTriggered: this._isUserTriggered
    };
  }

  /**
   * 更新 userId（动态传入）
   */
  updateUserId(userId) {
    console.log('更新 userId:', userId);
    
    // ✅ 防止重复更新
    if (this._isUpdatingUserId) {
      console.log('⚠️ userId 正在更新中，跳过重复调用');
      return Promise.resolve();
    }
    
    if (this._rewardedVideoAd) {
      // ✅ 重新创建广告实例，传入新的 userId
      const oldAd = this._rewardedVideoAd;
      
      // ✅ 设置更新标记
      this._isUpdatingUserId = true;
      
      // 销毁旧实例（等待销毁完成）
      return new Promise((resolve) => {
        try {
          oldAd.destroy();
          console.log('✅ 旧广告实例已销毁');
          
          // ✅ 立即设置为 null
          this._rewardedVideoAd = null;
          
          // 等待一小段时间确保旧实例完全销毁
          setTimeout(() => {
            // 保存新的 userId
            this._userId = userId;
            
            console.log(`创建新广告实例，userId: ${userId}`);
            
            // ✅ 检查是否已经有实例（防止重复创建）
            if (this._rewardedVideoAd) {
              console.error('⚠️ 警告：已经有广告实例存在，跳过创建新实例');
              this._isUpdatingUserId = false;
              resolve();
              return;
            }
            
            // 创建新实例
            console.log(`✅ 开始创建新广告实例，userId: ${userId}`);
            this._rewardedVideoAd = uni.createRewardedVideoAd({
              adpid: '1748458063',
              urlCallback: {
                userId: userId,
              }
            });
            
            console.log(`✅ 新广告实例创建完成`);
            
            // 重新绑定事件
            this._bindEvents();
            
            // 重置加载状态
            this._isLoadedAd = false;
            
            // ✅ 清除更新标记
            this._isUpdatingUserId = false;
            
            // 自动加载
            this._rewardedVideoAd.load().then(() => {
              console.log('✅ 广告重新加载成功（使用新userId）');
              resolve();
            }).catch((err) => {
              console.log('广告重新加载失败:', err);
              this._isUpdatingUserId = false;
              resolve();
            });
          }, 200);
        } catch (e) {
          console.error('销毁旧实例失败:', e);
          this._isUpdatingUserId = false;
          resolve();
        }
      });
    } else {
      // ✅ 如果没有实例，保存 userId，后续创建时会用到
      this._userId = userId;
      console.warn('广告实例不存在，保存 userId，等待实例创建时使用');
      return Promise.resolve();
    }
  }

  /**
   * 重置重试计数（对外暴露）
   */
  resetRetryCount() {
    this._retryCount = 0;
    this._silentRetryCount = 0;  // ✅ 同时重置静默重试计数
    console.log('重试计数已重置');
  }

  /**
   * 销毁广告实例
   */
  destroy() {
    // ✅ 清理静默重试定时器
    if (this._silentRetryTimer) {
      clearTimeout(this._silentRetryTimer);
      this._silentRetryTimer = null;
    }

    if (this._rewardedVideoAd) {
      this._rewardedVideoAd.destroy();
      this._rewardedVideoAd = null;
    }
    this._isLoadedAd = false;
    this._isLoading = false;
    this._retryCount = 0;
    this._silentRetryCount = 0;  // ✅ 重置静默重试计数
    this._isUserTriggered = false;  // ✅ 重置用户触发标志
    this._isShowingDialog = false;  // ✅ 重置弹窗显示标记
    this._userId = null;  // ✅ 重置 userId
    this._isUpdatingUserId = false;  // ✅ 重置更新标记
    console.log('广告管理器已销毁');
  }
}

// 导出单例
export default new RewardVideoAdManager();